\input texinfo    @c -*- texinfo -*-
@c %**start of header
@setfilename list.info
@settitle Guile Awesome List
@documentencoding UTF-8
@documentlanguage English
@c %**end of header

@finalout
@titlepage
@title Guile Awesome List
@author Zelphir Kaltstahl (help & input from Guile community)
@end titlepage

@contents

@ifnottex
@node Top
@top Guile Awesome List
@end ifnottex

@menu
* Manuals::
* Tutorials / Guides / Books::
* Libraries::
* Projects::
* Programming paradigm::
* Programming language concepts::
* Programs::
* Tools::
* Blogs::
* Other: Other (7). 
* Other lists of Guile software::
* Videos / Talks / Presentations::

@detailmenu
--- The Detailed Node Listing ---

Tutorials / Guides / Books

* General GNU Guile / Scheme::
* Macros::
* Monads::
* FFI - Foreign Function Interface::
* GUI development::

Macros

* CK macros::

Libraries

* Async::
* Audio::
* Browser::
* Bots::
* Chat::
* Compression::
* Computer vision::
* Configuration::
* Cryptography::
* Databases::
* Data structures::
* Debugging::
* Decentralization::
* Development environments::
* Device management::
* Distributed computing::
* E-Mail::
* Encodings::
* Event loop::
* FFI - Foreign Function Interface: FFI - Foreign Function Interface (1). 
* File formats::
* File system::
* Game development::
* Games::
* Generators::
* Genomics::
* Graphics::
* GUI development: GUI development (1). 
* Language::
* Logging::
* Machine Learning::
* Macros: Macros (1). 
* Message Queues::
* Network programming::
* Parallelism::
* Parsing::
* Plotting::
* Protocols::
* Serialization::
* SRFI (Scheme Request For Implementation) implementations::
* Strings::
* Syntax::
* Regular expressions::
* REPL (Read Eval Print Loop)::
* RPC (Remote Procedure Call)::
* Scientific computing and mathematics::
* Search engine::
* Shell::
* TUI development::
* Testing::
* Types::
* Version control systems::
* Web Development::
* Window manager::
* Working with code::
* Other::
* Unsorted::

Chat

* Chat clients::
* Chat bots::
* Protocols: Protocols (1). 

Databases

* Generic::
* Postgres::
* Sqlite::
* MySQL::
* Redis::
* CouchDB::
* Other: Other (1). 

Data structures

* Purely functional data structures (PFDs)::
* RDF::
* Lenses::
* Trees::
* Other: Other (2). 

File formats

* JSON::
* YAML::
* CSV::
* XML::
* Markdown::
* Texinfo::
* JPEG::
* PNG::
* ICS::
* torrent::
* Shapefile::
* CBOR::
* TAR::
* INI::
* Other: Other (3). 

Graphics

* Image processing::
* Design and CAD::

Parsing

* Parser Combinators::
* Parser Generator::
* Other: Other (4). 
* XML parser::

Scientific computing and mathematics

* Interaction with the Jupyter ecosystem::

Testing

* Integration testing::
* Unit testing::
* Other: Other (5). 

Types

* Static typing::

Web Development

* Web servers::
* Web clients::
* Web frameworks::
* Protocols: Protocols (2). 
* Tooling / Additional libraries::
* Static website generators::
* Template engine::
* Interaction with services::
* Web application examples::
* Web drivers / Selenium::

Programming paradigm

* "Object-oriented programming"::
* Relational programming::
* Functional programming::

"Object-oriented programming"

* Prototype based::

Programming language concepts

* Pipeline / pipe / chain / threading::
* State Machines::

Programs

* Finances::
* Window manager: Window manager (1). 
* Other: Other (6). 

Tools

* Notes::
* Editor support::
* Project management::
* Build tools::

Project management

* Package managers::
* Time tracking::

@end detailmenu
@end menu

@node Manuals
@chapter Manuals

@itemize
@item
There is a huge reference manual for GNU Guile on the GNU website: @uref{https://www.gnu.org/software/guile/manual/}.
@end itemize

@node Tutorials / Guides / Books
@chapter Tutorials / Guides / Books

@menu
* General GNU Guile / Scheme::
* Macros::
* Monads::
* FFI - Foreign Function Interface::
* GUI development::
@end menu

@node General GNU Guile / Scheme
@section General GNU Guile / Scheme

@itemize
@item
Guile reference manual
@itemize
@item
website: @uref{https://www.gnu.org/software/guile/manual/}
@end itemize

@item
official Guile tutorial
@itemize
@item
website: @uref{https://www.gnu.org/software/guile/docs/guile-tut/tutorial.html}
@end itemize

@item
Structure and Interpretation of Computer Programs (SICP)
@itemize
@item
website: @uref{https://mitpress.mit.edu/sites/default/files/sicp/index.html}
@item
PDF version: @uref{https://github.com/sarabander/sicp-pdf}
@end itemize

@item
The Little Schemer
@itemize
@item
website: @uref{https://mitpress.mit.edu/books/little-schemer-fourth-edition}
@end itemize

@item
"Learn Scheme in 15 minutes"
@itemize
@item
website: @uref{https://web-artanis.com/scheme.html}
@end itemize

@item
guile-tutorial
@itemize
@item
git repo: @uref{https://notabug.org/cwebber/guile-tutorial}
@end itemize

@item
Guile Hacker Handbook
@itemize
@item
website: @uref{https://jeko.frama.io/en/index.html}
@item
git repo: @uref{https://framagit.org/Jeko/jeko.frama.io}
@end itemize

@item
The Scheme Programming Language
@itemize
@item
web version: @uref{https://scheme.com/tspl4/}
@end itemize

@item
A Pamphlet Against R
@itemize
@item
PDF version: @uref{https://github.com/panicz/pamphlet/raw/master/pamphlet.pdf}
@item
source codes: @uref{https://github.com/panicz/pamphlet}
@end itemize

@item
Concrete Abstractions - An Introduction to Computer Science Using Scheme
@itemize
@item
web: @uref{https://gustavus.edu/mcs/max/concrete-abstractions-pdfs/index.html}
@end itemize
@end itemize

@node Macros
@section Macros

@itemize
@item
Macros in the GNU Guile reference manual
@itemize
@item
website: @uref{https://www.gnu.org/software/guile/manual/html_node/Macros.html}
@end itemize

@item
Writing Hygienic Macros in Scheme with Syntax-Case
@itemize
@item
article: @uref{https://doc.lagout.org/programmation/Lisp/Scheme/Programming%20With%20Hygienic%20Macros%20-%20R%20K%20Dybvig.pdf}
@end itemize

@item
Community Scheme Wiki about macros
@itemize
@item
scheme-faq-macros
@itemize
@item
website: @uref{http://community.schemewiki.org/?scheme-faq-macros}
@end itemize
@item
syntax-case
@itemize
@item
website: @uref{http://community.schemewiki.org/?syntax-case}
@end itemize
@end itemize

@item
A Scheme Syntax-Rules Primer
@itemize
@item
website: @uref{http://www.willdonnelly.net/blog/scheme-syntax-rules/}
@end itemize

@item
Macro-by-Example: Deriving Syntactic Transformations from their Specifications
@itemize
@item
paper: @uref{https://legacy.cs.indiana.edu/ftp/techreports/TR206.pdf}
@end itemize

@item
wikibooks.org about macros
@itemize
@item
website: @uref{https://en.wikibooks.org/wiki/Scheme_Programming/Macros}
@end itemize

@item
Advanced Scheme Techniques - Some Naughty Bits
@itemize
@item
slides: @uref{http://people.csail.mit.edu/jhbrown/scheme/macroslides04.pdf}
@end itemize

@item
C2 Wiki Scheme Macro Examples
@itemize
@item
website: @uref{http://wiki.c2.com/?SchemeMacroExamples}
@end itemize

@item
JRM's Syntax-rules Primer for the Merely Eccentric
@itemize
@item
website: @uref{https://hipster.home.xs4all.nl/lib/scheme/gauche/define-syntax-primer.txt}
@itemize
@item
another location: @uref{http://www.phyast.pitt.edu/~micheles/syntax-rules.pdf}
@end itemize
@end itemize

@item
Scheme Macros I: Modules
@itemize
@item
website: @uref{https://blog.veitheller.de/Scheme_Macros_I:_Modules.html}
@end itemize

@item
Writing Macros in Continuation-Passing Style
@itemize
@item
paper: @uref{https://www.semanticscholar.org/paper/Writing-Macros-in-Continuation-Passing-Style-Hilsdale-Friedman/752575dc24b2bb6e74ee6146df71860e10e3aee9#citing-papers} (TODO: find a more permanent looking link)
@end itemize

@item
Low- and high-level macro programming in Scheme
@itemize
@item
website: @uref{http://okmij.org/ftp/Scheme/macros.html}
@end itemize
@end itemize

@menu
* CK macros::
@end menu

@node CK macros
@subsection CK macros

@itemize
@item
Applicative syntax-rules: macros that compose better
@itemize
@item
website: @uref{http://okmij.org/ftp/Scheme/macros.html#ck-macros}
@end itemize

@item
Chicken Scheme Wiki about ck-macros
@itemize
@item
website: @uref{http://wiki.call-cc.org/eggref/5/ck-macros}
@end itemize
@end itemize

@node Monads
@section Monads

@itemize
@item
A Schemer's Introduction to Monads
@itemize
@item
website: @uref{http://www.ccs.neu.edu/home/dherman/research/tutorials/monads-for-schemers.txt}
@end itemize

@item
A Schemer’s View of Monads - Partial Draft
@itemize
@item
website: @uref{https://cgi.sice.indiana.edu/~c311/lib/exe/fetch.php?media=manymonads.pdf}
@end itemize

@item
Monadic Programming in Scheme
@itemize
@item
website: @uref{http://okmij.org/ftp/Scheme/monad-in-Scheme.html}
@end itemize

@item
Panicz Godek's answer to How would you explain a concept of monads to a non-CS person?
@itemize
@item
website @uref{https://www.quora.com/How-would-you-explain-a-concept-of-monads-to-a-non-CS-person/answer/Panicz-Godek}
@end itemize

@item
Panicz Godek's answer to @uref{https://www.quora.com/Why-do-so-many-programmers-not-understand-the-theory-of-monads/answer/Panicz-Godek}
@itemize
@item
website @uref{https://www.quora.com/Why-do-so-many-programmers-not-understand-the-theory-of-monads/answer/Panicz-Godek}
@end itemize
@end itemize

@node FFI - Foreign Function Interface
@section FFI - Foreign Function Interface

@itemize
@item
GNU Guile standard library FFI
@itemize
@item
GNU software reference manual: @uref{https://www.gnu.org/software/guile/manual/html_node/Foreign-Function-Interface.html}
@end itemize
@end itemize

@node GUI development
@section GUI development

@itemize
@item
@code{gtk-tutorial-using-guile-gnome}
@itemize
@item
git repo: @uref{https://github.com/yang-qu/gtk-tutorial-using-guile-gnome}
@item
description: @emph{"This project converts C code in gtk tutorial @uref{http://www.zetcode.com/tutorials/gtktutorial}} to scheme code using guile-gnome."/ (@uref{https://github.com/yang-qu/gtk-tutorial-using-guile-gnome/blob/ec4e9ce9c670b923fc3cc973c1e85fc7934ff4d8/README})
@end itemize
@end itemize

@node Libraries
@chapter Libraries

@menu
* Async::
* Audio::
* Browser::
* Bots::
* Chat::
* Compression::
* Computer vision::
* Configuration::
* Cryptography::
* Databases::
* Data structures::
* Debugging::
* Decentralization::
* Development environments::
* Device management::
* Distributed computing::
* E-Mail::
* Encodings::
* Event loop::
* FFI - Foreign Function Interface: FFI - Foreign Function Interface (1). 
* File formats::
* File system::
* Game development::
* Games::
* Generators::
* Genomics::
* Graphics::
* GUI development: GUI development (1). 
* Language::
* Logging::
* Machine Learning::
* Macros: Macros (1). 
* Message Queues::
* Network programming::
* Parallelism::
* Parsing::
* Plotting::
* Protocols::
* Serialization::
* SRFI (Scheme Request For Implementation) implementations::
* Strings::
* Syntax::
* Regular expressions::
* REPL (Read Eval Print Loop)::
* RPC (Remote Procedure Call)::
* Scientific computing and mathematics::
* Search engine::
* Shell::
* TUI development::
* Testing::
* Types::
* Version control systems::
* Web Development::
* Window manager::
* Working with code::
* Other::
* Unsorted::
@end menu

@node Async
@section Async

@itemize
@item
8sync
@itemize
@item
git repository at Savannah: @uref{https://savannah.gnu.org/projects/8sync}
@item
manual / GNU software manual: @uref{https://www.gnu.org/software/8sync/manual/html_node/index.html#Top}
@item
website / GNU software page: @uref{https://www.gnu.org/software/8sync/}
@item
tutorial: @uref{https://www.gnu.org/software/8sync/manual/html_node/Tutorial.html#Tutorial}
@end itemize
@end itemize

@node Audio
@section Audio

@itemize
@item
@code{gapd}
@itemize
@item
git repo: @uref{https://github.com/rashack/gapd}
@item
description: @emph{"Guile Audio Player Daemon"} (@uref{https://github.com/rashack/gapd})
@end itemize

@item
@code{xmms2-guile}
@itemize
@item
git repository: @uref{https://gitlab.com/ft/xmms2-guile}
@item
description: @emph{"Native XMMS2 client library for GNU Guile."} -- @uref{https://gitlab.com/ft/xmms2-guile} @@ @samp{b26d67cd2cb8100c17244c7bcf50b496e90c98ae}
@end itemize
@end itemize

@node Browser
@section Browser

@itemize
@item
Nomad
@itemize
@item
git repository at non-GNU Savannah: @uref{https://savannah.nongnu.org/projects/nomad/}
@item
website: @uref{https://www.nongnu.org/nomad/}
@end itemize
@end itemize

@node Bots
@section Bots

@itemize
@item
@code{chatter}
@itemize
@item
git repo: @uref{https://github.com/apg/chatter}
@item
description: @emph{"Chatter Bot framework, inspired by Elizabot, for Guile"} (@uref{https://github.com/apg/chatter/blob/e407b09e9aedb214e75ffaecbcc86ed105f154aa/README})
@end itemize
@end itemize

@node Chat
@section Chat

@menu
* Chat clients::
* Chat bots::
* Protocols: Protocols (1). 
@end menu

@node Chat clients
@subsection Chat clients



@enumerate
@item
@anchor{IRC}IRC


@itemize
@item
@code{guile-irc}
@itemize
@item
git repository at GitHub: @uref{https://github.com/rekado/guile-irc}
@item
description: @emph{"An irc library for GNU guile."} (@uref{https://github.com/rekado/guile-irc/blob/master/README})
@item
API reference manual: @uref{http://fbs.github.io/guile-irc/}
@end itemize
@end itemize
@end enumerate

@node Chat bots
@subsection Chat bots



@enumerate
@item
@anchor{IRC (1)}IRC


@itemize
@item
Cunning Bot
@itemize
@item
git repo: @uref{https://github.com/cadrspace/cunning-bot}
@item
description:
@quotation
Cunning Bot is a command-oriented IRC bot written in Guile Scheme.

(@uref{https://github.com/cadrspace/cunning-bot/blob/cadrobot/README})

@end quotation
@end itemize

@item
@code{eliug}
@itemize
@item
git repo: @uref{https://github.com/szdiy/eliug}
@item
description: @emph{"the smart irc bot written with GNU Guile-scheme"} (@uref{https://github.com/szdiy/eliug/blob/030bf891a4007e9c40f8fdacd306c77e71146334/README.md})
@end itemize
@end itemize
@end enumerate

@node Protocols (1)
@subsection Protocols



@enumerate
@item
@anchor{Matrix}Matrix


@itemize
@item
@code{guile-deck}
@itemize
@item
repository: @uref{https://github.com/artyom-poptsov/guile-deck}
@item
description: @emph{"GNU Guile SDK for the Matrix network (@uref{https://matrix.org})"} -- @uref{https://github.com/artyom-poptsov/guile-deck/blob/7df7512501fb9a6fe879fb95857dc172b5a8fc22/README, README file}
@end itemize
@end itemize
@end enumerate

@node Compression
@section Compression

@itemize
@item
@code{guile-zlib}
@itemize
@item
git repository at GitHub: @uref{https://github.com/davexunit/guile-zlib}
@end itemize

@item
@code{guile-zstd}
@itemize
@item
git repository at notabug.org: @uref{https://notabug.org/guile-zstd/guile-zstd}
@item
description: @emph{"GNU Guile bindings to the zstd compression library."} (@uref{https://notabug.org/guile-zstd/guile-zstd})
@end itemize
@end itemize

@node Computer vision
@section Computer vision

@itemize
@item
GNU Guile-CV
@itemize
@item
website: @uref{https://www.gnu.org/software/guile-cv/}
@item
GNU software reference manual: @uref{https://www.gnu.org/software/guile-cv/manual/html_node/index.html}
@item
description:
@quotation
Guile-CV - Image Processing and Analysis in Guile - is a Computer Vision functional programming library for the Guile Scheme language.

Guile-CV is based on Vigra (Vision with Generic Algorithms), enhanced with additional algorithms (Image Textures, Delineate, Reconstruction and many more), all accessible through a nice, clean and easy to use high level API@.

Guile-CV is natively multi-threaded, and takes advantage of multiple cores, using high-level and fine grained application-level parallelism constructs available in Guile, based on its support to POSIX threads.

(@uref{https://www.gnu.org/software/guile-cv/index.html})

@end quotation
@end itemize
@end itemize

@node Configuration
@section Configuration

@itemize
@item
@code{guile-config}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/a-sassmannshausen/guile-config}
@end itemize
@end itemize

@node Cryptography
@section Cryptography

@itemize
@item
@code{guile-gcrypt}
@itemize
@item
git repo: @uref{https://notabug.org/cwebber/guile-gcrypt}
@item
description:
@quotation
    Guile-Gcrypt provides a Guile 3.x/2.x interface to a subset of the GNU
Libgcrypt crytographic library, which is itself used by the GNU Privacy Guard
(GPG).

    Guile-Gcrypt provides modules for cryptographic hash functions, message
authentication codes (MAC), public-key cryptography, strong randomness, and
more. It is implemented using the foreign function interface (FFI) of Guile.

@end quotation
@end itemize

@item
@code{gcrypt-guile}
@itemize
@item
git repo: @uref{https://github.com/fbs/gcrypt-guile} (archived, read only)
@item
description: @emph{"Wrappers to get some libgcrypt functionality into guile."} (@uref{https://github.com/fbs/gcrypt-guile/blob/0add93e2486044ca48f3de130a070fba21bf0b2d/README})
@end itemize
@end itemize

@node Databases
@section Databases

@menu
* Generic::
* Postgres::
* Sqlite::
* MySQL::
* Redis::
* CouchDB::
* Other: Other (1). 
@end menu

@node Generic
@subsection Generic

@itemize
@item
Generic
@itemize
@item
@code{guile-dbi}
@itemize
@item
git repository at GitHub: @uref{https://github.com/opencog/guile-dbi}
@item
documentation: @uref{https://htmlpreview.github.io/?https://github.com/opencog/guile-dbi/blob/master/website/guile-dbi.html}
@item
offers MySQL, Postgresql and SQLite3 interfaces
@end itemize
@end itemize
@end itemize

@node Postgres
@subsection Postgres

@itemize
@item
@code{guile-squee}
@itemize
@item
git repository at notabug.org: @uref{https://notabug.org/cwebber/guile-squee}
@item
documentation at: ???
@end itemize

@item
@code{guile-dbd-postgresql}
@itemize
@item
git repository: @uref{https://github.com/opencog/guile-dbi/tree/master/guile-dbd-postgresql}
@item
documentation: @uref{https://github.com/opencog/guile-dbi/blob/master/guile-dbd-postgresql/README}
@item
description: This is a sub-repository of @code{guile-dbi} which is used for dealing with the Postgres side of things.
@end itemize

@item
Guile-PG
@itemize
@item
git repository: @uref{https://git.savannah.nongnu.org/cgit/guile-pg.git}
@item
documentation: ???
@item
project page: @uref{https://www.nongnu.org/guile-pg/}
@item
description: @emph{"Guile-PG is a collection of modules for Guile allowing access to the PostgreSQL RDBMS from Scheme programs."} (@uref{https://www.nongnu.org/guile-pg/})
@end itemize
@end itemize

@node Sqlite
@subsection Sqlite

@itemize
@item
@code{guile-sqlite3}
@itemize
@item
git repository at notabug.org: @uref{https://notabug.org/guile-sqlite3/guile-sqlite3.git}
@item
documentation at: ???
@end itemize

@item
@code{guile-dbd-sqlite3}
@itemize
@item
git repository at GitHub: @uref{https://github.com/opencog/guile-dbi/tree/master/guile-dbd-sqlite3}
@item
documentation: @uref{https://github.com/opencog/guile-dbi/blob/master/guile-dbd-sqlite3/README}
@item
description: This is a sub-repository of @code{guile-dbi} which is used for dealing with the Sqlite3 side of things.
@end itemize
@end itemize

@node MySQL
@subsection MySQL

@itemize
@item
@code{guile-dbd-mysql}
@itemize
@item
git repository at GitHub: @uref{https://github.com/opencog/guile-dbi/tree/master/guile-dbd-mysql}
@item
documentation: @uref{https://github.com/opencog/guile-dbi/blob/master/guile-dbd-mysql/README}
@item
description: This is a sub-repository of @code{guile-dbi} which is used for dealing with the MySQL side of things.
@end itemize
@end itemize

@node Redis
@subsection Redis

@itemize
@item
@code{guile-redis}
@itemize
@item
git repository at GitHub: @uref{https://github.com/aconchillo/guile-redis}
@end itemize
@end itemize

@node CouchDB
@subsection CouchDB

@itemize
@item
CouchDB
@itemize
@item
@code{guile-couchdb}
@item
git repo: @uref{https://github.com/ukulanne/guile-couchdb}
@item
description: CouchDB bindings for Guile
@end itemize
@end itemize

@node Other (1)
@subsection Other

@itemize
@item
WiredTiger (@uref{http://www.wiredtiger.com/}
@itemize
@item
@code{guile-wiredtiger}
@itemize
@item
blog post: @uref{https://hyper.dev/blog/getting-started-with-guile-wiredtiger.html}
@item
git repository at: ??? (framagit requires login?)
@end itemize
@end itemize

@item
@code{guile-sparql}: @uref{https://github.com/roelj/guile-sparql}

@item
@code{sparqling-genomics}: @uref{https://github.com/UMCUGenetics/sparqling-genomics}

@item
@code{nomunofu}
@itemize
@item
mentioned on: @uref{https://hyper.dev/blog/nomunofu.html}
@item
git repo: ???
@end itemize

@item
@code{gsparql}
@itemize
@item
git repo: @uref{https://github.com/cordawyn/gsparql}
@item
description: @emph{"SPARQL client written in Guile"} (@uref{https://github.com/cordawyn/gsparql/blob/4076e435cc852a5c91922be5ffc7e201bb35d935/README.md})
@end itemize
@end itemize

@node Data structures
@section Data structures

@menu
* Purely functional data structures (PFDs)::
* RDF::
* Lenses::
* Trees::
* Other: Other (2). 
@end menu

@node Purely functional data structures (PFDs)
@subsection Purely functional data structures (PFDs)

@itemize
@item
@code{pfds}
@itemize
@item
git repository at GitHub: @uref{https://github.com/ijp/pfds}
@item
description: @emph{"pfds is a set of purely functional data structures written in R6RS Scheme. It has been tested with Racket, Guile 2, Vicare Scheme and IronScheme."} (@uref{https://github.com/ijp/pfds/blob/454033f82dac7c0b0ea9e84eed1e8ed316487c78/README.org})
@item
documentation: @uref{https://github.com/ijp/pfds/blob/master/README.org}
@end itemize

@item
@code{fectors}
@itemize
@item
git repository at GitHub: @uref{https://github.com/ijp/fectors}
@itemize
@item
perhaps fork or original or another library: @uref{https://hg.sr.ht/~bjoli/guile-fector}
@end itemize
@end itemize

@item
@code{guile-fash}
@itemize
@item
mercurial repo: @uref{https://hg.sr.ht/~bjoli/guile-fash}
@item
description: @emph{"guile-fash implements functional hashes using Hash array mapped tries (HAMTs)."} (@uref{https://hg.sr.ht/~bjoli/guile-fash/browse/readme.md?rev=tip})
@item
guix package: none
@end itemize
@end itemize

@node RDF
@subsection RDF

@itemize
@item
@code{guile-rdf}
@itemize
@item
git repository at framagit: @uref{https://framagit.org/tyreunom/guile-rdf}
@end itemize
@end itemize

@node Lenses
@subsection Lenses

@itemize
@item
@code{guile-lens}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/a-sassmannshausen/guile-lens}
@end itemize
@end itemize

@node Trees
@subsection Trees

@itemize
@item
Guile AA Tree
@itemize
@item
project page: @uref{https://savannah.nongnu.org/projects/guile-aa-tree}
@item
git repo: @uref{https://git.savannah.nongnu.org/cgit/guile-aa-tree.git}
@item
description: @emph{"An AA tree implementation for scheme. AA trees are self-balancing binary trees, which ensure O(log n) worst case performance for core operations. The module provides non-mutating insert, delete, and search operations, with support for convenient nested tree operations."} (@uref{https://savannah.nongnu.org/projects/guile-aa-tree})
@end itemize
@end itemize

@node Other (2)
@subsection Other

@itemize
@item
@code{copernic}
@itemize
@item
git repository at GitHub: @uref{https://github.com/amirouche/copernic}
@end itemize

@item
@code{scheme-bytestructures}
@itemize
@item
git repo: @uref{https://github.com/TaylanUB/scheme-bytestructures}
@item
description:
@quotation
[@dots{}] offers a system imitating the type system of the C programming language, to be used on bytevectors. C's type system works on raw memory, and ours works on bytevectors which are an abstraction over raw memory in Scheme. The system is in fact more powerful than the C type system, elevating types to first-class status.

@end quotation
@end itemize

@item
@code{guile-newra}
@itemize
@item
git repo: @uref{https://github.com/lloda/guile-newra}
@item
description: "A Scheme replacement for Guile's array system" (@uref{https://github.com/lloda/guile-newra})
@end itemize

@item
Treaps
@itemize
@item
website: @uref{http://okmij.org/ftp/Scheme/#treaps}
@item
description:
@quotation
An ordered dictionary data structure, based on randomized search trees (treaps) by Seidel and Aragon. Compared to red-black trees, treap is simpler and more elegant, and can get by without sentinels.

(@uref{http://okmij.org/ftp/Scheme/#treaps})

@end quotation
@end itemize

@item
@code{array-list}
@itemize
@item
repository: @uref{https://git.dthompson.us/chickadee.git/tree/chickadee/array-list.scm}
@item
description: an implementation of a dynamic array (@uref{https://en.wikipedia.org/wiki/Dynamic_array})
@end itemize
@end itemize

@node Debugging
@section Debugging

@itemize
@item
@code{guile-jtd}
@itemize
@item
repository: @uref{https://github.com/mwette/guile-jtd}
@item
description:

@quotation
jump-to-debugger: like Python's pdb.set@math{_trace}(), but for Guile

The `(jtd)` module for Guile provides a procedure (jump-to-debugger)
for escaping to the Guile REPL for the purpose of debugging code.
It should be considered beta code, still under development.

-- @uref{https://raw.githubusercontent.com/mwette/guile-jtd/cb40b0e0f2fa2a1825a5f1f273b6970be2fe1401/README.md}

@end quotation

@item
documentation: @uref{https://github.com/mwette/guile-jtd/blob/main/README.md}
@end itemize
@end itemize

@node Decentralization
@section Decentralization

@itemize
@item
@code{wispwot}
@itemize
@item
repository: @uref{https://hg.sr.ht/~arnebab/wispwot/browse}
@item
description:
@quotation
This implements the defense from the Freenet project against disruption of
communication. It is created to experiment with ways to improve the scaling
and performance.

-- @uref{https://hg.sr.ht/~arnebab/wispwot}

@end quotation
@end itemize
@end itemize

@node Development environments
@section Development environments

@itemize
@item
@code{guile-studio}
@itemize
@item
git repo: @uref{https://git.elephly.net/gitweb.cgi?p=software/guile-studio.git;a=tree}
@item
description:
@quotation
Racket has Dr Racket.  Guile has @dots{} Emacs?  This is Emacs with a few
settings that make working with Guile easier for people new to Emacs.
Features include: CUA mode, Geiser, tool bar icons to evaluate Guile
buffers, support for Guile's very own picture language, code completion, a
simple mode line, etc. [@dots{}]

@end quotation
(@uref{https://git.elephly.net/gitweb.cgi?p=software/guile-studio.git;a=blob;f=README.org;hb=HEAD})
@end itemize
@end itemize

@node Device management
@section Device management

@itemize
@item
@code{guile-udev}:
@itemize
@item
description: @emph{"Guile-Udev is a GNU Guile bindings to libudev."} (@uref{https://github.com/artyom-poptsov/guile-udev/blob/master/README})
@item
git repo: @uref{https://github.com/artyom-poptsov/guile-udev}
@item
documentation: (inside the git repo: @uref{https://github.com/artyom-poptsov/guile-udev/blob/master/doc/guile-udev.texi})
@item
examples: (inside the git repo: @uref{https://github.com/artyom-poptsov/guile-udev/tree/master/examples})
@end itemize
@end itemize

@node Distributed computing
@section Distributed computing

@itemize
@item
@code{metabash}
@itemize
@item
git repository: @uref{https://github.com/artyom-poptsov/metabash}
@item
description: @emph{"GNU Guile module for running distributed shell pipelines."} -- @uref{https://github.com/artyom-poptsov/metabash/blob/master/README.org}
@end itemize
@end itemize

@node E-Mail
@section E-Mail

@itemize
@item
GNU Mailutils ??? (@uref{https://mailutils.org/})

@item
@code{guile-email}: @uref{https://guile-email.systemreboot.net/}
@end itemize

@node Encodings
@section Encodings

@itemize
@item
ERIS - Encoding for Robust Immutable Storage
@itemize
@item
website: @uref{http://purl.org/eris}
@item
git repository: @uref{https://gitlab.com/openengiadina/eris/-/tree/main}
@item
description: @emph{"ERIS is an encoding for arbitrary content into uniformly sized encrypted blocks that can be reassembled only in possession of a short read capability."} -- @uref{https://gitlab.com/openengiadina/eris/-/blob/88c54329c1f7357941ae3a4bac49847c022c9803/README.org}
@end itemize
@end itemize

@node Event loop
@section Event loop

@itemize
@item
@code{guile-a-sync}
@itemize
@item
git repository at GitHub: @uref{https://github.com/ChrisVine/guile-a-sync}
@item
documentation: ?
@end itemize
@end itemize

@node FFI - Foreign Function Interface (1)
@section FFI - Foreign Function Interface

@itemize
@item
GNU Guile standard library FFI
@itemize
@item
GNU software reference manual: @uref{https://www.gnu.org/software/guile/manual/html_node/Foreign-Function-Interface.html}
@end itemize

@item
@code{ffi-helper} from NYACC
@itemize
@item
documentation: @uref{https://www.nongnu.org/nyacc/ffi-help.html}
@end itemize
@end itemize

@node File formats
@section File formats

@menu
* JSON::
* YAML::
* CSV::
* XML::
* Markdown::
* Texinfo::
* JPEG::
* PNG::
* ICS::
* torrent::
* Shapefile::
* CBOR::
* TAR::
* INI::
* Other: Other (3). 
@end menu

@node JSON
@subsection JSON

@itemize
@item
@code{guile-json}
@itemize
@item
on GitHub: @uref{https://github.com/aconchillo/guile-json}
@item
on savannah: @uref{http://savannah.nongnu.org/projects/guile-json/}
@end itemize

@item
@code{guile-json} (another one)
@itemize
@item
git repo: @uref{https://github.com/cthom06/guile-json}
@item
description: @emph{"A basic JSON parser for Guile"} (@uref{https://github.com/cthom06/guile-json/blob/1b2f77c4242fa52d6f8624806ec0c47e0d2ca08a/README})
@end itemize
@end itemize

@node YAML
@subsection YAML

@itemize
@item
@code{guile-libyaml}
@itemize
@item
git repo: @uref{https://github.com/mwette/guile-libyaml}
@item
description: @emph{"simple yaml module using ffi-helper from www.nongnu.org/nyacc"} (@uref{https://github.com/mwette/guile-libyaml/blob/f5d33a6880e96571d3cb079ed7755ffc156cac46/README.md})
@end itemize
@end itemize

@node CSV
@subsection CSV

@itemize
@item
@code{guile-csv}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/NalaGinrut/guile-csv}
@end itemize

@item
@code{guile-dsv}
@itemize
@item
This is more general, but can work with CSV as well.
@item
git repository at GitHub: @uref{https://github.com/artyom-poptsov/guile-dsv}
@end itemize
@end itemize

@node XML
@subsection XML

@itemize
@item
Guile's standard library SXML implementation
@itemize
@item
GNU software manual: @uref{https://www.gnu.org/software/guile/manual/html_node/SXML.html}
@item
Basically your templates become functions or macros.
@item
The structure of your document is kept as Scheme data structures.
@itemize
@item
This avoids having parse the document as a long string into an internal data structure to perform semantic transformations.
@item
It enables pattern matching without resorting to things like regular expressions and similar shenanigans.
@end itemize
@end itemize
@end itemize

@node Markdown
@subsection Markdown

@itemize
@item
@code{guile-commonmark}
@itemize
@item
git repository at GitHub: @uref{https://github.com/OrangeShark/guile-commonmark}
@item
documentation: ???
@end itemize
@end itemize

@node Texinfo
@subsection Texinfo

@itemize
@item
Guile standard library texinfo functionality
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/texinfo.html}
@end itemize
@end itemize

@node JPEG
@subsection JPEG

@itemize
@item
@code{guile-jpeg}: a library for parsing JPEG files
@itemize
@item
git repo: @uref{https://github.com/guildhall/guile-jpeg} (archived)
@end itemize
@end itemize

@node PNG
@subsection PNG

@itemize
@item
@samp{guile-PNG}
@itemize
@item
git repo: @uref{https://github.com/artyom-poptsov/guile-png}
@item
description: "Portable Network Graphics (PNG, RFC 2083) library for GNU Guile." --  @uref{https://github.com/artyom-poptsov/guile-png/blob/06bb2c734c3007346f970be6f6a00407ac5d76f0/README.org}
@end itemize
@end itemize

@node ICS
@subsection ICS

@itemize
@item
@code{guile-ics}
@itemize
@item
git repository at GitHub: @uref{https://github.com/artyom-poptsov/guile-ics}
@end itemize
@end itemize

@node torrent
@subsection torrent

@itemize
@item
@code{torrent}
@itemize
@item
git repository at GitHub: @uref{https://github.com/o-nly/torrent}
@item
documentation at: ???
@end itemize
@end itemize

@node Shapefile
@subsection Shapefile

@itemize
@item
@code{guile-shapefile}
@itemize
@item
git repository: @uref{https://github.com/HugoNikanor/guile-shapefile}
@item
description: @emph{"Guile Shapefile is a Guile library for reading shapefiles."} (@uref{https://github.com/HugoNikanor/guile-shapefile/blob/37fd219d3dc3d944e8f29b1bad6baf9e59372275/README.md})
@item
documentation: @uref{https://hugonikanor.github.io/guile-shapefile/}
@end itemize
@end itemize

@node CBOR
@subsection CBOR

@itemize
@item
@code{guile-cbor}
@itemize
@item
git repo: @uref{https://inqlab.net/git/guile-cbor.git/}
@item
description:
@quotation
The Concise Binary Object Representation (CBOR), as specified by RFC 8949,
is a binary data serialization format. CBOR is similar to JSON but
serializes to binary which is smaller and faster to generate and parse.

@end quotation
@end itemize
@end itemize

@node TAR
@subsection TAR

There is no standalone library for TAR files yet (2021-11-15), but there is code dealing with TAR files, which might be separatable into its own library:

@itemize
@item
Implementation of Ustar in Gash:
@itemize
@item
@uref{https://git.savannah.nongnu.org/cgit/gash/gash-utils.git/tree/gash/commands/tar.scm}
@item
@uref{https://git.savannah.nongnu.org/cgit/gash/gash-utils.git/tree/gash/ustar.scm}
@end itemize
@item
GNU Tar stuff:
@itemize
@item
@uref{https://git.savannah.gnu.org/cgit/tar.git/tree/src/tar.h}
@item
@uref{https://savannah.gnu.org/git/?group=tar}
@item
@uref{https://www.gnu.org/software/tar/}
@end itemize
@end itemize

@node INI
@subsection INI

@itemize
@item
@code{Guile-INI}
@itemize
@item
git repository: @uref{https://github.com/artyom-poptsov/guile-ini}
@item
description: @emph{"A GNU Guile library for working with INI format."} (@uref{https://github.com/artyom-poptsov/guile-ini/blob/6764a8a23d8d5911c08ee2bc996cb776e6b0ae5e/README.org})
@item
documentation: @uref{https://github.com/artyom-poptsov/guile-ini/tree/master/doc}
@end itemize
@end itemize

@node Other (3)
@subsection Other

@itemize
@item
@code{guile-mime}
@itemize
@item
git repo: @uref{https://mikegerwitz.com/projects/guile-mime/tree/}
@item
description: A library, that helps figuring out the MIME type of a file.
@end itemize

@item
If the input is not input from users and is trustworthy, one might be able to leverage read/write of s-expressions instead of using other formats.
@end itemize

@node File system
@section File system

@itemize
@item
@code{sdupes}
@itemize
@item
description: duplicate file detection
@item
git repository at GitHub: @uref{https://github.com/sph-mn/sdupes}
@end itemize

@item
@code{duplicates}
@itemize
@item
git repo: @uref{https://github.com/rashack/duplicates}
@item
description: @emph{"Find duplicate files - in Guile Scheme"} (@uref{https://github.com/rashack/duplicates})
@end itemize

@item
@code{guile-filesystem}
@itemize
@item
git repo: @uref{https://gitlab.com/lilyp/guile-filesystem}
@item
description: "[@dots{}] provides a set of utilities to deal with the filesystem beyond what POSIX mandates, from manipulating file names to actually creating files and directories." -- @uref{https://gitlab.com/lilyp/guile-filesystem/-/blob/f1f7f45c23a8662abdecc4b054b4da64f3cc868f/README.org}
@end itemize

@item
@code{guile-fslib}
@itemize
@item
git repo: @uref{https://notabug.org/ZelphirKaltstahl/guile-fslib}
@item
description: "guile-fslib is a library, which contains procedures for working with filenames. It simplifies common tasks like splitting, joining and getting the file extension of a filename." -- @uref{https://notabug.org/ZelphirKaltstahl/guile-fslib/src/67266331dc9be54cc4c7bf2a6b814815c21e44e1/README.org}
@end itemize
@end itemize

@node Game development
@section Game development

@itemize
@item
Chickadee
@itemize
@item
describes itself as "game development toolkit"
@item
OpenGL based
@item
website: @uref{https://dthompson.us/projects/chickadee.html}
@item
manual: @uref{https://dthompson.us/manuals/chickadee/index.html}
@end itemize

@item
@code{guile-allegro5}
@itemize
@item
git repo: @uref{https://github.com/davexunit/guile-allegro5}
@item
description: @emph{"Allegro 5 is a cross-platform, open source, game programming library written in C@. Guile-allegro5 is a collection of modules that provides bindings for Guile."} (@uref{https://github.com/davexunit/guile-allegro5/blob/614ecc978e034f7b7ba5bd23e27111c8fef81b56/README.md})
@end itemize

@item
@code{gzochi}
@itemize
@item
git repo: @uref{https://git.savannah.gnu.org/cgit/gzochi.git}
@item
project page: @uref{https://www.nongnu.org/gzochi/}
@item
documentation: @uref{https://www.nongnu.org/gzochi/gzochid.html}
@item
description:

@quotation
gzochi (@emph{zoʊ-tʃiː}) is a programming framework for developing online games
in GNU Guile, and a distributed middleware container that hosts your games
for thousands of connected players. gzochi takes care of the hard parts of
online game development - concurrency, data persistence, and network
communications - so you can focus on the stuff that matters!

@end quotation

(@uref{https://www.nongnu.org/gzochi/})
@end itemize
@end itemize

@node Games
@section Games

@itemize
@item
StayAlive
@itemize
@item
git repo: @uref{https://github.com/mwitmer/StayAlive}
@end itemize

@item
dryads-wake
@itemize
@item
git repo: @uref{https://hg.sr.ht/~arnebab/dryads-wake}
@item
description:

@quotation
Dryads Wake is a game of dialogue and choices.
(@uref{https://hg.sr.ht/~arnebab/dryads-wake})

@end quotation
@end itemize

@item
@code{guile-mud}
@itemize
@item
git repo: @uref{https://github.com/NalaGinrut/guile-mud}
@item
description: ???
@end itemize

@item
@code{game_of_life}
@itemize
@item
git repo: @uref{https://github.com/deathgrindfreak/game_of_life}
@item
description: @emph{"An implementation of Conway's Game of Life in Guile Scheme."} (@uref{https://github.com/deathgrindfreak/game_of_life/blob/501f7d3c0dc50a3cbac8df3620f8e507f32d5aa5/README.md})
@end itemize
@end itemize

@node Generators
@section Generators

@itemize
@item
C-Ast
@itemize
@item
git repo: @uref{https://github.com/zenhack/c-ast}
@item
description: @emph{"C-Ast is a GNU Guile library for generating C code."} (@uref{https://github.com/zenhack/c-ast/blob/5af5758ccae5e468587cda837e1fd9e685205bef/README.md})
@end itemize
@end itemize

@node Genomics
@section Genomics

@itemize
@item
@code{sparqling-genomics}
@itemize
@item
git repo: @uref{https://github.com/UMCUGenetics/sparqling-genomics}
@item
description:
@quotation
This project provides programs to extract RDF triplets from commonly used file formats in genomics. It also provides a web-based environment to explore the RDF triplets once inserted in a triple store.

(@uref{https://github.com/UMCUGenetics/sparqling-genomics})

@end quotation
@item
usage example: @uref{https://github.com/UMCUGenetics/sparqling-genomics/blob/dc5fea515c30aa26ff60b77911438689473d125b/web/ldap/authenticate.scm.in#L148}
@end itemize
@end itemize

@node Graphics
@section Graphics

@itemize
@item
@code{guile-sdl}
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/guile-sdl/}
@item
gnuvola page of examples: @uref{http://www.gnuvola.org/software/guile-sdl-demos/}
@item
gnuvola software page: @uref{http://www.gnuvola.org/software/guile-sdl-demos/}
@end itemize

@item
@code{guile-sdl2}
@itemize
@item
project website: @uref{https://dthompson.us/projects/guile-sdl2.html}
@end itemize

@item
@code{guile-opengl}
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/guile-opengl/}
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile-opengl/manual/guile-opengl.html}
@item
git repository at Savannah: @uref{http://savannah.gnu.org/projects/guile-opengl}
@end itemize

@item
@code{guile-cairo}
@itemize
@item
git repository at Savannah: @uref{http://savannah.nongnu.org/projects/guile-cairo}
@end itemize

@item
@code{guile-jpeg}: a library for parsing JPEG files
@itemize
@item
git repository at GitHub: @uref{https://github.com/guildhall/guile-jpeg}
@end itemize
@end itemize

@menu
* Image processing::
* Design and CAD::
@end menu

@node Image processing
@subsection Image processing

@itemize
@item
@code{guile-cv}
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/guile-cv/}
@item
git repository at Savannah: @uref{http://git.savannah.gnu.org/cgit/guile-cv.git}
@end itemize

@item
@code{guile-picture-language}
@itemize
@item
website: @uref{https://elephly.net/guile-picture-language/}
@item
repository: @uref{https://git.elephly.net/gitweb.cgi?p=software/guile-picture-language.git}
@item
manual: @uref{https://elephly.net/guile-picture-language/manual.html}
@end itemize
@end itemize

@node Design and CAD
@subsection Design and CAD

@itemize
@item
@code{libfive}
@itemize
@item
website: @uref{https://libfive.com/}
@item
git repository: @uref{https://github.com/libfive/libfive}
@item
description:

@quotation
"libfive is a software library and set of tools for solid modeling, especially suited for parametric and procedural design. It is infrastructure for generative design, mass customization, and domain-specific CAD tools."

-- @uref{https://libfive.com/} (2021-05-13)

@end quotation

libfive itself is not written in GNU Guile, but interaction with it include
using GNU Guile as a modelling language.
@end itemize
@end itemize

@node GUI development (1)
@section GUI development

@itemize
@item
@code{guile-gi}
@itemize
@item
git repository at GitHub: @uref{https://github.com/spk121/guile-gi}
@item
documentation at: @uref{https://spk121.github.io/guile-gi/}
@item
description:
@quotation
This is a library for GNU Guile to create language bindings via GObject Introspection.

GNU Guile is an implementation of Scheme, which is a Lisp-like language. This library allows Guile to use GObject-based libraries -- such as GTK+3, GLib, and WebKit2 -- by generating a Scheme API from the GObject Introspection information provided by those libraries.

[@dots{}]

-- @uref{https://raw.githubusercontent.com/spk121/guile-gi/c4a9b8d11debe9a633a4be936f1bbf4b7098fe66/README.md}

@end quotation
@end itemize

@item
@code{guile-gnome}
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/guile-gnome/}
@item
git repository at Savannah: @uref{http://git.savannah.gnu.org/cgit/guile-gnome.git}
@end itemize

@item
@code{guile-gtk}
@itemize
@item
website: @uref{https://www.gnu.org/software/guile-gtk/}
@item
CVS repository at non-GNU Savannah: @uref{http://savannah.nongnu.org/projects/guile-gtk/}
@end itemize

@item
@code{g-golf}: @uref{https://www.gnu.org/software/g-golf/}

@item
@samp{guile-webview}
@itemize
@item
git repository: @uref{https://github.com/KikyTokamuro/guile-webview}
@item
description: @emph{"Wrapper for using libwebview from GNU Guile"} -- @uref{https://github.com/KikyTokamuro/guile-webview/blob/a2af7bc339e777b05e304158bcfae23815d8bcef/README.md}
@item
documentation: @uref{https://github.com/KikyTokamuro/guile-webview/tree/main/examples}
@end itemize
@end itemize

@node Language
@section Language

@itemize
@item
@code{guile-aspell}
@itemize
@item
git repository at GitHub: @uref{https://github.com/spk121/guile-aspell}
@item
website: @uref{http://lonelycactus.com/guile-aspell.html}
@end itemize
@end itemize

@node Logging
@section Logging

@itemize
@item
@code{guile-logging}
@itemize
@item
git repository at GitHub: @uref{https://github.com/shanecelis/guile-logging}
@end itemize

@item
SysLog proposal
@itemize
@item
git repo: @uref{https://bitbucket.org/cowan/r7rs-wg1-infra/src/default/SyslogCowan.md}
@item
description: This is a specification for an implementation of syslog.
@end itemize

@item
logging module of @code{sparqling-genomics}
@itemize
@item
git repo: @uref{https://github.com/UMCUGenetics/sparqling-genomics/blob/master/web/logger.scm}
@item
description: This is what @code{sparqling-genomics} uses internally.
@end itemize
@end itemize

@node Machine Learning
@section Machine Learning

@itemize
@item
decision tree
@itemize
@item
@code{guile-ml}
@itemize
@item
repository at notabug.org: @uref{https://notabug.org/ZelphirKaltstahl/guile-ml}
@end itemize
@end itemize

@item
@code{guile-snowball-stemmer}
@itemize
@item
mentioned on: @uref{https://snowballstem.org/projects.html}
@item
mentioned on: @uref{https://github.com/snowballstem/snowball/issues/34#issuecomment-491056371}
@item
git repo: unfortunately the link to the repository is broken
@end itemize

@item
AIscm
@itemize
@item
website: @uref{http://wedesoft.github.io/aiscm/}
@item
description:
@quotation
AIscm is a Guile extension for numerical arrays and tensors. Performance is achieved by using the LLVM JIT compiler.

(@uref{http://wedesoft.github.io/aiscm/})

@end quotation
@end itemize
@end itemize

@node Macros (1)
@section Macros

@itemize
@item
@code{guile-for-loops}
@itemize
@item
mercurial repo: @uref{https://hg.sr.ht/~bjoli/guile-for-loops}
@item
description:
@quotation
A re-implementation of a large-ish chunk of rackets for-macros. It is mostly compatible with racket's macros, with the largest omission being the body-or-break clause and some of the sequence iterators (like in-cycle, which can be covered by circular lists). There are other differences of course, like for/foldr not being on par feature-wise, and all the nicities you get by having a generic sequence interfce.

[@dots{}]

(@uref{https://hg.sr.ht/~bjoli/guile-for-loops/browse/README.md?rev=580d3fb365ea2734b037ad3ca7f2ab1e4aa5116d})

@end quotation
@end itemize

@item
@code{goof-loop}
@itemize
@item
repository: @uref{https://git.sr.ht/~bjoli/goof-loop/}
@item
description:

@quotation
goof-loop - a scheme looping facility

goof-loops aims to be an amalgamation of the racket for loops and Alex Shinn's (chibi-loop). We are many that found racket's for loops a breeze of fresh air, but in the end their most general forms (for/fold and for/foldr) are kinda odd to work with. If you choose not to use those general for loops, you cannot express arbitrary transformations, like say a fibonacci sequence, since for clauses cannot reference eachother. goof-loop tries to fix this [@dots{}]

-- @uref{https://git.sr.ht/~bjoli/goof-loop/tree/cccc324ecd14325d9f2fe4c7eabd8bc217823d32/item/README.md}

@end quotation
@end itemize

@item
@code{megacut} macro:
@itemize
@item
mercurial repo: @uref{https://hg.sr.ht/~bjoli/megacut}
@item
description:
@quotation
This is  a clojure-like lambda shorthand for guile. The macro is called megacut (which is a bad name, since it is not much like cut).

(@uref{https://hg.sr.ht/~bjoli/megacut/browse/readme.txt?rev=75caf96aa4a9282d489230fe56fff4f1aa5e2564})

@end quotation
@end itemize

@item
GNU Thales
@itemize
@item
project page: @uref{https://savannah.gnu.org/projects/thales}
@item
git repo: @uref{https://git.savannah.gnu.org/cgit/thales.git}
@item
description: @emph{"GNU Thales is set of GNU Guile macroses to perform doctests."} (@uref{https://savannah.gnu.org/projects/thales})
@end itemize

@item
Documentation for Scheme Syntax Extension Packages in SLIB
@itemize
@item
website: @uref{https://people.csail.mit.edu/jaffer/slib/Scheme-Syntax-Extension-Packages.html#Scheme-Syntax-Extension-Packages}
@end itemize

@item
Implementation of function contracts: @uref{https://notabug.org/ZelphirKaltstahl/guile-examples/src/master/macros/contract.scm}
@end itemize

@node Message Queues
@section Message Queues

@itemize
@item
Zero MQ
@itemize
@item
@code{guile-zmq}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/NalaGinrut/guile-zmq}
@end itemize
@item
@code{guile-simple-zmq}
@itemize
@item
git repository at GitHub: @uref{https://github.com/jerry40/guile-simple-zmq}
@end itemize
@end itemize
@end itemize

@node Network programming
@section Network programming

@itemize
@item
Guile's standard library networking module
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/Networking.html}
@end itemize

@item
@code{guile-curl}
@itemize
@item
git repository at GitHub: @uref{https://github.com/spk121/guile-curl}
@end itemize

@item
@code{guile-ssh}
@itemize
@item
git repository at GitHub: @uref{https://github.com/artyom-poptsov/guile-ssh}
@end itemize

@item
GNU Serveez
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/serveez/}
@item
manual: @uref{https://www.gnu.org/software/serveez/manual/}
@item
git repository at Savannah: @uref{http://savannah.gnu.org/projects/serveez/}
@end itemize

@item
@code{serveez-mg}
@itemize
@item
git repository at GitHub @uref{https://github.com/spk121/serveez-mg}
@item
based on GNU Serveez
@end itemize

@item
@code{stis-engine}
@itemize
@item
git repository at: @uref{https://gitlab.com/tampe/stis-engine}
@item
description: @emph{"Communication layer ontop of guile fibers"} -- @uref{https://gitlab.com/tampe/stis-engine}
@end itemize

@item
@samp{Scheme-GNUnet}
@itemize
@item
git repository: @uref{https://git.gnunet.org/gnunet-scheme.git/}
@item
description:
@quotation
Scheme-GNUnet is a WIP (Guile) Scheme port of the GNUnet client libraries.
Unlike gnunet-guile, it is not a binding for the C libraries.  It can be
used in multi-threaded applications, e.g. with guile-fibers.

It is not to be confused with @uref{https://git.gnunet.org/gnunet-guile2.git}
and @uref{https://git.savannah.gnu.org/cgit/guix/gnunet.git}, which implement
bindings for the C libraries and support a different set of services.

-- Guile user mailing list

@end quotation
@item
documentation: @uref{https://git.gnunet.org/gnunet-scheme.git/tree/doc}
@end itemize
@end itemize

@node Parallelism
@section Parallelism

@itemize
@item
standard library futures
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/docs/docs-2.2/guile-ref/Futures.html} (link to Guile 2.2 docs -- Where are the 3.x docs?)
@item
description:
@quotation
[@dots{}] a construct for fine-grain parallelism. A future is a wrapper around an expression whose computation may occur in parallel with the code of the calling thread, and possibly in parallel with other futures. Like promises, futures are essentially proxies that can be queried to obtain the value of the enclosed expression [@dots{}]

@end quotation
@end itemize

@item
@code{guile-fibers}
@itemize
@item
git repo: @uref{https://github.com/wingo/fibers}
@item
description:
@quotation
Concurrent ML-like concurrency for Guile

@end quotation
@end itemize

@item
standard library parallel forms
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/Parallel-Forms.html}
@item
note: Sometimes the parallel forms might cause errors, see @uref{https://lists.gnu.org/archive/html/guile-user/2020-01/msg00092.html}, I recommend to use futures or if suitable @code{guile-fibers} instead.
@end itemize

@item
@samp{guile-parallel}
@itemize
@item
git repo: @uref{https://git.sr.ht/~old/guile-parallel}
@item
description: "High level structures and procedures for parallelism." -- @uref{https://git.sr.ht/~old/guile-parallel/tree/dc1a55ea2499b6ca4355e9aae1d7256effd14355/item/README.md}
@end itemize
@end itemize

@node Parsing
@section Parsing

@menu
* Parser Combinators::
* Parser Generator::
* Other: Other (4). 
* XML parser::
@end menu

@node Parser Combinators
@subsection Parser Combinators

@itemize
@item
@code{stis-parser}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/tampe/stis-parser}
@end itemize
@end itemize

@node Parser Generator
@subsection Parser Generator

@itemize
@item
@code{nyacc}: Not Yet Another Compiler Compiler
@itemize
@item
git repository at Savannah: @uref{https://savannah.nongnu.org/projects/nyacc}
@item
documentation: @uref{https://www.nongnu.org/nyacc/nyacc-ug.html}
@end itemize
@end itemize

@node Other (4)
@subsection Other

@itemize
@item
standard library PEG parsing
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/PEG-Parsing.html}
@item
description:
@quotation
Parsing Expression Grammars (PEGs) are a way of specifying formal languages for text processing.

(@uref{https://www.gnu.org/software/guile/manual/html_node/PEG-Parsing.html})

@end quotation
@end itemize
@end itemize

@node XML parser
@subsection XML parser

@itemize
@item
Mixp:
@itemize
@item
git repository: @uref{https://git.savannah.nongnu.org/cgit/mixp.git}
@item
website: @uref{https://www.nongnu.org/mixp/}
@item
description: @emph{"Mixp is a set of modules for Guile that wrap libexpat and provide higher-level utilities. [@dots{}]"} (@uref{https://savannah.nongnu.org/projects/mixp})
@item
documentation: ???
@end itemize
@end itemize

@node Plotting
@section Plotting

@itemize
@item
@code{guile-plotutils}
@itemize
@item
git repository at GitHub: @uref{https://github.com/spk121/guile-plotutils}
@item
website: @uref{https://www.gnu.org/software/plotutils/plotutils.html}
@end itemize
@end itemize

@node Protocols
@section Protocols

@itemize
@item
X protocol
@itemize
@item
@code{guile-xcb}
@itemize
@item
git repo: @uref{https://github.com/mwitmer/guile-xcb}
@end itemize
@end itemize
@end itemize

@node Serialization
@section Serialization

@itemize
@item
@code{guile-msgpack}
@itemize
@item
git repo: @uref{https://gitlab.com/HiPhish/guile-msgpack}
@item
description:
@quotation
This is a GNU Guile library implementing the MessagePack data serialisation format. It allows you to serialise (pack) and de-serialise (unpack) Scheme objects to and from binary data according to the MessagePack format.

(@uref{https://gitlab.com/HiPhish/guile-msgpack/-/blob/master/README.rst})

@end quotation
@end itemize

@item
@code{stis-data}
@itemize
@item
git repo: @uref{https://gitlab.com/tampe/stis-data}
@item
description: @emph{"Serializing guile datastructures into binary format"} -- @uref{https://gitlab.com/tampe/stis-data/-/blob/08d2de0ceef22f87083221b1b59c91de76836bd9/README.md}
@end itemize
@end itemize

@node SRFI (Scheme Request For Implementation) implementations
@section SRFI (Scheme Request For Implementation) implementations

@itemize
@item
@code{TaylanUB/scheme-srfis}
@itemize
@item
git repo: @uref{https://github.com/TaylanUB/scheme-srfis}
@item
description: This repository contains implementations for some SRFIs.
@end itemize

@item
@code{srfi-78-guile}
@itemize
@item
git repo: @uref{https://github.com/sunjoong/srfi-78-guile}
@item
description: @emph{"SRFI 78: Lightweight testing by Sebastian Egner"} (@uref{https://github.com/sunjoong/srfi-78-guile})
@end itemize

@item
@code{guile-srfi89}
@itemize
@item
git repo: @uref{https://gitlab.com/mjbecze/guile-srfi-89}
@item
description: @emph{"This is a hygienic implemention of SRFI 89 (Optional positional and named parameters) for Guile Scheme."} (@uref{https://gitlab.com/mjbecze/guile-srfi-89/-/blob/0c907086e809c69faaac75ce2feeb3ba1694f037/README.md})
@end itemize

@item
@code{srfi-151}
@itemize
@item
git repo: @uref{https://github.com/ft/srfi-151}
@item
description: @emph{"SRFI-151 — Bitwise Operations — Implementation for GNU Guile"} (@uref{https://github.com/ft/srfi-151/blob/486ee152c826ad07eaf4e8765e8c20842dba0915/README})
@item
license: @uref{https://github.com/ft/srfi-151/blob/486ee152c826ad07eaf4e8765e8c20842dba0915/LICENCE}
@item
documentation: @uref{https://srfi.schemers.org/srfi-151/srfi-151.html}
@end itemize

@item
@code{scheme-libraries}
@itemize
@item
repository: @uref{https://launchpad.net/scheme-libraries}
@end itemize

@item
@code{wisp}
@itemize
@item
mercurial repo: @uref{https://hg.sr.ht/~arnebab/wisp}
@item
website: @uref{http://draketo.de/english/wisp}, @uref{https://srfi.schemers.org/srfi-119/srfi-119.html}
@item
GNU Guix package: @code{guile-wisp}
@item
description: @emph{"wisp: simpler indentation-sensitive scheme"} (@uref{https://srfi.schemers.org/srfi-119/srfi-119.html})
@end itemize

@item
@code{awesome-coroutine-generators}
@itemize
@item
git repository: @uref{https://git.sr.ht/~bjoli/awesome-coroutine-generators/tree}
@item
description: an implementation of SRFI-158
@end itemize

@item
double ended queue
@itemize
@item
website: @uref{https://srfi.schemers.org/srfi-134/srfi-134.html}
@item
repository: @uref{https://github.com/scheme-requests-for-implementation/srfi-134/}
@end itemize
@end itemize

@node Strings
@section Strings

@itemize
@item
@code{guile-raw-strings}
@itemize
@item
git repo: @uref{https://github.com/lloda/guile-raw-strings}
@end itemize
@end itemize

@node Syntax
@section Syntax

@itemize
@item
(grand scheme) glossary
@itemize
@item
git repo: @uref{https://github.com/plande/grand-scheme}
@end itemize
@end itemize

@node Regular expressions
@section Regular expressions

@itemize
@item
IrRegular Expressions (Scheme, R[4567]RS)
@itemize
@item
website: @uref{http://synthcode.com/scheme/irregex}
@end itemize
@end itemize

@node REPL (Read Eval Print Loop)
@section REPL (Read Eval Print Loop)

@itemize
@item
@code{guile-colorized}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/NalaGinrut/guile-colorized}
@end itemize
@end itemize

@node RPC (Remote Procedure Call)
@section RPC (Remote Procedure Call)

@itemize
@item
GNU Guile-RPC
@itemize
@item
website: @uref{https://www.gnu.org/software/guile-rpc/}
@item
documentation: @uref{https://www.gnu.org/software/guile-rpc/manual/}
@item
git repo: @uref{http://git.savannah.gnu.org/gitweb/?p=guile-rpc.git}
@end itemize

@item
@code{guile-xmlrpc}:
@itemize
@item
description:
@quotation
guile-xmlrpc is an XMLRPC module for Guile. Guile already has the wonderful sxml module that allows XML document creation and parsing. guile-xmlrpc goes one step further and combines sxml with some macros and procedures that simplifies even more the creation and parsing of XMLRPC documents.

(@uref{https://github.com/aconchillo/guile-xmlrpc/blob/master/README.org})

@end quotation
@item
git repo: @uref{https://github.com/aconchillo/guile-xmlrpc}
@item
manual: (readme file in git repo)
@end itemize
@end itemize

@node Scientific computing and mathematics
@section Scientific computing and mathematics

@itemize
@item
GNU Scientific Library (GSL)
@itemize
@item
GNU software page @uref{https://www.gnu.org/software/gsl/}
@item
git repository at Savannah: @uref{http://savannah.gnu.org/projects/gsl/}
@item
wikipedia page: @uref{https://en.wikipedia.org/wiki/GNU_Scientific_Library}
@item
Guile bindings: @uref{http://community.schemewiki.org/?gee-guile-gsl}
@end itemize

@item
Matrix multiplication
@itemize
@item
@code{guile-ffi-cblas}
@itemize
@item
git repository at GitHub: @uref{https://github.com/lloda/guile-ffi-cblas}
@end itemize
@end itemize

@item
Fast Fourier Transformation
@itemize
@item
@code{guile-ffi-fftw} by lloda
@itemize
@item
git repo: @uref{https://github.com/lloda/guile-ffi-fftw}
@item
description: @emph{"A simple wrapper for FFTW, using Guile's FFI"} (@uref{https://github.com/lloda/guile-ffi-fftw})
@end itemize
@item
@code{guile-ffi-fftw} by Mikael Djurfeldt
@itemize
@item
git repo at Savannah: @uref{https://savannah.nongnu.org/projects/guile-fftw}
@item
description:
@end itemize
@end itemize

@item
Symbolic mathematics
@itemize
@item
@code{guile-scmutils}
@itemize
@item
website: @uref{https://www.cs.rochester.edu/~gildea/guile-scmutils/}
@item
download: @uref{https://www.cs.rochester.edu/~gildea/guile-scmutils/guile-scmutils-v1.0.tgz}
@item
description:
@quotation
A port of the scmutils package for symbolic mathematics from mit scheme to guile, in an effort to make scmutils and the examples from the Structure and Interpretation of Classical Mechanics available on a wider variety of architectures/operating systems.

(@uref{https://www.cs.rochester.edu/~gildea/guile-scmutils/})

@end quotation
@end itemize
@end itemize

@item
Guile implementation of symbolic mathematics shown in SICP
@itemize
@item
Does this exist?
@end itemize
@end itemize

@menu
* Interaction with the Jupyter ecosystem::
@end menu

@node Interaction with the Jupyter ecosystem
@subsection Interaction with the Jupyter ecosystem

@itemize
@item
@code{guix-kernel}
@itemize
@item
git repository at gitlab.inria.fr: @uref{https://gitlab.inria.fr/guix-hpc/guix-kernel}
@item
blog post: @uref{https://hpc.guix.info/blog/2019/10/towards-reproducible-jupyter-notebooks/}
@end itemize

@item
@code{guile-kernel}
@itemize
@item
git repository at GitHub: @uref{https://github.com/jerry40/guile-kernel}
@end itemize
@end itemize

@node Search engine
@section Search engine

@itemize
@item
@code{babelia}
@itemize
@item
git repo: @uref{https://github.com/amirouche/babelia}
@item
description:
@quotation
Wanna be search engine with federation support

(@uref{https://github.com/amirouche/babelia})

@end quotation
@end itemize
@end itemize

@node Shell
@section Shell

@itemize
@item
@code{gash}
@itemize
@item
git repo: @uref{https://git.savannah.nongnu.org/cgit/gash.git}
@item
description:

@quotation
Gash is a POSIX-compatible shell written in Guile Scheme. It provides both
the shell interface, as well as a Guile library for parsing shell scripts.
Gash is designed to bootstrap Bash as part of the Guix bootstrap process.
We are planning to develop Gash into a general-purpose shell and tool for
building interfaces between Scheme and the shell.

@end quotation

(@uref{https://git.savannah.nongnu.org/cgit/gash.git/tree/README?id=8f9b973264cc799df27795df6230839e96dc00eb})
@end itemize
@end itemize

@node TUI development
@section TUI development

@itemize
@item
@code{guile-ncurses}
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/guile-ncurses/}
@item
git repository at GitHub: @uref{https://github.com/guildhall/guile-ncurses}
@end itemize

@item
@code{guile-termios}
@itemize
@item
git repository: @uref{https://gitlab.com/ft/guile-termios}
@item
description:
@quotation
POSIX termios interface for GNU Guile

To query and change settings of serial devices on POSIX systems, the termios
API is used. GNU Guile doesn't have an interface for that built in. This module
implements this interface by use of Guile's dynamic FFI@.

[@dots{}]

-- @uref{https://gitlab.com/ft/guile-termios/-/blob/29dfd68bdc64d6cea0cd4a50757439b77523e9f5/README}

@end quotation
@item
license: @uref{https://gitlab.com/ft/guile-termios/-/blob/29dfd68bdc64d6cea0cd4a50757439b77523e9f5/LICENCE}
@end itemize
@end itemize

@node Testing
@section Testing

@menu
* Integration testing::
* Unit testing::
* Other: Other (5). 
@end menu

@node Integration testing
@subsection Integration testing

@itemize
@item
@code{guix-cuirass}
@itemize
@item
git repo: @uref{https://gitlab.com/mothacehe/guix-cuirass}
@item
website: ???
@end itemize
@end itemize

@node Unit testing
@subsection Unit testing

@itemize
@item
srfi-64 (@uref{https://srfi.schemers.org/srfi-64/srfi-64.html})
@itemize
@item
GNU software Guile manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/SRFI_002d64.html}
@end itemize

@item
@code{srfi-64-driver}
@itemize
@item
git repository at: ???
@item
website: @uref{https://ngyro.com/software/srfi-64-driver.html}
@end itemize

@item
@code{guile-testing}
@itemize
@item
git repository at: @uref{https://github.com/wedesoft/guile-testing}
@item
description: @emph{"This is an example on how to do unit-testing using GNU Guile, Automake Test Anything Protocol (TAP), and SRFI-64."} (@uref{https://github.com/wedesoft/guile-testing/blob/598768b04fe9ef13e07401f1bd715f5fb3bb964e/README.md})
@end itemize

@item
@code{guile-unit}
@itemize
@item
git repository: ??? (was at @uref{https://github.com/sirius94/guile-unit})
@item
description: ???
@end itemize

@item
@code{ggspec}
@itemize
@item
git repo: @uref{https://github.com/yawaramin/ggspec}
@item
description: @emph{"lightweight unit testing library for Guile"} (@uref{https://github.com/yawaramin/ggspec/blob/97dab55962f63d9692475b171fd6fbd76ac64731/README.md})
@end itemize
@end itemize

@enumerate
@item
@anchor{TAP output}TAP output


@itemize
@item
@code{guile-tap}
@itemize
@item
git repo: @uref{https://github.com/xevz/guile-tap}
@item
description: @emph{"Simple Guile module which provides TAP compilant output."} (@uref{https://github.com/xevz/guile-tap})
@end itemize

@item
@code{guile-tap}
@itemize
@item
Yes there are 2!
@item
git repo: @uref{https://gitlab.com/ft/guile-tap}
@item
description: @emph{"This is a library for GNU Guile that implements a framework for specifying test cases that emit output that adheres to the Test Anything Protocol (TAP)¹."} (@uref{https://gitlab.com/ft/guile-tap/-/blob/87edc4b74bfe0774af0211c06a30366a44c1371a/README})
@item
license: @uref{https://gitlab.com/ft/guile-tap/-/blob/87edc4b74bfe0774af0211c06a30366a44c1371a/LICENCE}

@item
@code{scm-test-tap}
@itemize
@item
git repo: @uref{https://github.com/ft/scm-test-tap}
@item
description: @emph{"TAP emitting test-framework for GNU Guile"} (@uref{https://github.com/ft/scm-test-tap})
@end itemize
@end itemize
@end itemize
@end enumerate

@node Other (5)
@subsection Other

@itemize
@item
@code{guile-quickcheck}
@itemize
@item
git repo: @uref{https://git.ngyro.com/guile-quickcheck}
@item
website: @uref{https://ngyro.com/software/guile-quickcheck.html}
@item
description:
@quotation
This Guile library provides tools for randomized, property-based testing. It
follows closely the QuickCheck library written in Haskell, with inspiration
from the Racket version. You can use it to define a property (a predicate
with specifications for its inputs) and test it by generating many random
inputs and seeing if it holds.

-- @uref{https://ngyro.com/software/guile-quickcheck.html}

@end quotation
@end itemize

@item
@samp{guile-proba}
@itemize
@item
git repo: @uref{https://codeberg.org/luis-felipe/guile-proba}
@item
description:
@quotation
Guile Probá is a set of testing tools for GNU Guile projects with
SRFI 64-based test suites. It comes with a command-line interface
that allows you to autodiscover tests and run them, and a library
that includes a test runner and helpers for writing tests.

-- @uref{https://codeberg.org/luis-felipe/guile-proba/src/commit/f6b235072ec0f41dcdee8631d454c517e5637dbd/README.org}

@end quotation
@end itemize
@end itemize

@node Types
@section Types

@menu
* Static typing::
@end menu

@node Static typing
@subsection Static typing

@itemize
@item
@code{Theme-D}
@itemize
@item
source code: on website at: @uref{https://www.tohoyn.fi/theme-d/download.html}
@item
description:
@quotation
Programming language Theme-D extends Scheme with static typing. The current
Scheme platform is guile 3.0 but the software works for guile 2.2,
too. Theme-D resembles Jaap Weel's Theme but Theme-D is more dynamic and
the objects in Theme-D need to have type tags. See Theme-D-Golf for GNOME
bindings to Theme-D@.

-- @uref{https://www.tohoyn.fi/theme-d/index.html}

@end quotation
@item
license: parts as: LGPL-3, GFDL-1.3, GPL-3
@item
documentation:
@itemize
@item
examples: @uref{https://www.tohoyn.fi/theme-d/examples.html}
@item
docs: @uref{https://www.tohoyn.fi/theme-d/documentation.html}
@end itemize
@end itemize
@end itemize

@node Version control systems
@section Version control systems

@itemize
@item
@code{guile-git}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/guile-git/guile-git}
@end itemize

@item
@code{guile-semver}
@itemize
@item
git repository at ngyro: @uref{https://git.ngyro.com/guile-semver}
@item
website at: @uref{https://ngyro.com/software/guile-semver.html}
@end itemize
@end itemize

@node Web Development
@section Web Development

@menu
* Web servers::
* Web clients::
* Web frameworks::
* Protocols: Protocols (2). 
* Tooling / Additional libraries::
* Static website generators::
* Template engine::
* Interaction with services::
* Web application examples::
* Web drivers / Selenium::
@end menu

@node Web servers
@subsection Web servers

@itemize
@item
Guile's standard library's web server:
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/Web-Server.html}
@item
blog post about the performance of Guile's web server: @uref{http://wingolog.org/archives/2012/03/08/an-in-depth-look-at-the-performance-of-guiles-web-server}
@item
documentation as generic interface for web server implementations: @uref{https://www.gnu.org/software/guile/manual/html_node/Web-Server.html}
@item
examples for usage for creating a web app: @uref{https://www.gnu.org/software/guile/manual/html_node/Web-Examples.html#Web-Examples}
@end itemize

@item
@code{gappserver}
@itemize
@item
git repo: @uref{https://github.com/uberblah/gappserver}
@item
description: @emph{"a really tiny guile webserver"} (@uref{https://github.com/uberblah/gappserver})
@end itemize
@end itemize

@node Web clients
@subsection Web clients

@itemize
@item
@code{web-client-with-cache}
@itemize
@item
repository: @uref{https://labo.planete-kraus.eu/web-client-with-cache.git/}
@item
manual: @uref{https://web-client-with-cache.planete-kraus.eu/index.html}
@item
description: a caching web client
@end itemize
@end itemize

@node Web frameworks
@subsection Web frameworks

@itemize
@item
guile's-standard-library's web module for dealing with web stuff:
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/Web.html}
@end itemize

@item
GNU Artanis web application frameweork
@itemize
@item
GNU software page: @uref{https://www.gnu.org/software/artanis/}
@item
git repository at GitLab: @uref{https://gitlab.com/NalaGinrut/artanis}
@item
official website of the GNU Artanis project: @uref{https://web-artanis.com/}
@item
blog post about GNU Artanis: @uref{https://dev.to/heroku/an-ode-to-gnu-artanis-2gn3}
@item
manual:
@itemize
@item
@uref{https://www.gnu.org/software/artanis/manual/manual.html}
@item
@uref{https://www.gnu.org/software/artanis/manual/html_node/}
@end itemize
@item
blog post about using GNU Artanis in a docker container: @uref{https://nalaginrut.com/archives/2019/09/18/install%20gnu%20artanis%20with%20docker}
@end itemize

@item
SPH web app
@itemize
@item
git repository at GitHub: @uref{https://github.com/sph-mn/sph-web-app}
@end itemize

@item
Tekuti
@itemize
@item
git repository at GutHub: @uref{https://github.com/wingo/tekuti}
@item
blog post about tekuti: @uref{https://wingolog.org/projects/tekuti/}
@item
description: @emph{"Server-side blog engine written in Scheme"} (see repository), web blog using Git as its persistent store
@end itemize
@end itemize

@node Protocols (2)
@subsection Protocols



@enumerate
@item
@anchor{Web sockets}Web sockets


@itemize
@item
@code{guile-websocket}
@itemize
@item
git repo: @uref{https://git.dthompson.us/guile-websocket.git}
@item
description: @emph{"Guile-WebSocket is an implementation of the WebSocket protocol as defined by @uref{https://tools.ietf.org/html/rfc6455, RFC 6455}."} (@uref{https://git.dthompson.us/guile-websocket.git/tree/README?id=c854e0f84a40d972cbd532bbb89c97ca0126a7cf})
@end itemize
@end itemize
@end enumerate

@node Tooling / Additional libraries
@subsection Tooling / Additional libraries

@itemize
@item
JSON
@itemize
@item
@code{guile-json}
@itemize
@item
on GitHub: @uref{https://github.com/aconchillo/guile-json}
@item
on savannah: @uref{http://savannah.nongnu.org/projects/guile-json/}
@end itemize
@end itemize

@item
@code{guile-www}
@itemize
@item
git repository at savannah non-gnu: @uref{http://savannah.nongnu.org/projects/guile-www/}
@item
git repository at: @uref{https://github.com/guildhall/guile-www}
@item
description: @emph{"This is the Guile WWW library, a set of Guile Scheme modules to facilitate HTTP, URL and CGI programming."} (@uref{https://github.com/guildhall/guile-www/tree/263e9632bab062f0ec360c2d54b3bf7d1a4e9ba7})
@end itemize

@item
@code{guile-webutils}
@itemize
@item
git repository at notabug.org: @uref{https://notabug.org/cwebber/guile-webutils}
@end itemize

@item
@code{guile-html}
@itemize
@item
git repo: @uref{https://github.com/TaylanUB/guile-html}
@item
description:
@quotation
A tiny module to make it less annoying to make and write HTML files using SXML@. Read the code!

@end quotation
@end itemize
@end itemize

@enumerate
@item
@anchor{Authorization and authentication}Authorization and authentication


@itemize
@item
@code{guile-oauth}
@itemize
@item
git repository at GitHub: @uref{https://github.com/aconchillo/guile-oauth}
@end itemize

@item
@code{guile-jwt}
@itemize
@item
git repository on GitHub: @uref{https://github.com/aconchillo/guile-jwt}
@end itemize
@end itemize
@end enumerate

@node Static website generators
@subsection Static website generators

@itemize
@item
@code{guile-haunt}
@itemize
@item
git repository at GitHub: @uref{https://github.com/guildhall/guile-haunt}
@end itemize

@item
SPH static website generator
@itemize
@item
git repository at GitHub: @uref{https://github.com/sph-mn/sph-web-publish}
@end itemize
@end itemize

@node Template engine
@subsection Template engine

@itemize
@item
Guile's standard library SXML implementation
@itemize
@item
GNU software manual: @uref{https://www.gnu.org/software/guile/manual/html_node/SXML.html}
@item
Basically your templates become functions or macros.
@item
The structure of your document is kept as Scheme data structures.
@itemize
@item
This avoids having parse the document as a long string into an internal data structure to perform semantic transformations.
@item
It enables pattern matching without resorting to things like regular expressions and similar shenanigans.
@end itemize
@end itemize
@end itemize

@node Interaction with services
@subsection Interaction with services

@itemize
@item
@code{guile-mastodon}
@itemize
@item
git repository at framagit: @uref{https://framagit.org/prouby/guile-mastodon}
@item
documentation at: @uref{https://framagit.org/prouby/guile-mastodon/-/blob/master/doc/guile-mastodon.org}
@end itemize
@end itemize

@node Web application examples
@subsection Web application examples

@itemize
@item
@code{scheme-todomvc}:
@itemize
@item
git repo: @uref{https://github.com/amirouche/scheme-todomvc}
@item
demo: @uref{https://amirouche.github.io/scheme-todomvc/}
@end itemize
@end itemize

@node Web drivers / Selenium
@subsection Web drivers / Selenium

@itemize
@item
@code{guile-web-driver}
@itemize
@item
git repo: @uref{https://github.com/her01n/guile-web-driver}
@item
description: "web driver (selenium) client for guile" (@uref{https://github.com/her01n/guile-web-driver})
@end itemize
@end itemize

@node Window manager
@section Window manager

@itemize
@item
@code{guile-wm}
@itemize
@item
git repo: @uref{https://github.com/mwitmer/guile-wm}
@end itemize
@end itemize

@node Working with code
@section Working with code

@itemize
@item
@code{guile-syntax-highlight}
@itemize
@item
website: @uref{https://dthompson.us/projects/guile-syntax-highlight.html}
@item
git repository: @uref{https://git.dthompson.us/guile-syntax-highlight.git}
@end itemize

@item
@code{guile-syntax-parse}
@itemize
@item
git repo: @uref{https://gitlab.com/guile-syntax-parse/guile-syntax-parse}
@item
description: port of Racket's syntax parse to GNU Guile
@item
documentation: see @uref{https://docs.racket-lang.org/syntax-parse-example/index.html?q=syntax%20parse#%28part._.A_syntax-parse_.Crash_.Course%29}
@end itemize

@item
@samp{scheme-lsp-server}
@itemize
@item
git repository: @uref{https://codeberg.org/rgherdt/scheme-lsp-server}
@item
description:
@quotation
A LSP (Language Server Protocol) server for Scheme.

This software aims to support several Scheme implementations. To achieve this, the code is designed to contain as much logic as possible in R7RS Scheme, separating implementation-specific code in different directories.

Note: this code is still in an early development stage and the API may change. Change suggestions are welcome.

-- @uref{https://codeberg.org/rgherdt/scheme-lsp-server/src/commit/f9492cdf89c0680aeddb58478c0371d7d738d1b1/README.md}

@end quotation
@item
documentation: @uref{https://codeberg.org/rgherdt/scheme-lsp-server/src/branch/master/README.md}
@end itemize
@end itemize

@node Other
@section Other

@itemize
@item
@code{guile-lib}
@itemize
@item
git repository at non-GNU Savannah: @uref{http://git.savannah.nongnu.org/cgit/guile-lib.git}
@item
website at: @uref{https://www.nongnu.org/guile-lib/}
@item
description:
@quotation
guile-lib is intended as an accumulation place for pure-scheme Guile modules, allowing for people to cooperate integrating their generic Guile modules into a coherent library. Think "a down-scaled, limited-scope CPAN for Guile". [@dots{}]

(@uref{https://www.nongnu.org/guile-lib/})

@end quotation
@end itemize

@item
Spells
@itemize
@item
git repo: @uref{https://github.com/rotty/spells}
@item
description:
@quotation
Spells is a collection of R6RS libraries providing features beyond R6RS in a uniform way across supported implementations.

(@uref{https://github.com/rotty/spells/blob/master/README})

@end quotation
@item
documentation: @uref{http://rotty.xx.vu/software/spells/} (unfortunately 404 currently)
@end itemize

@item
SPH website:
@itemize
@item
It has some Guile library and project descriptions and links.
@item
@uref{http://sph.mn/}
@end itemize

@item
Grip
@itemize
@item
website: @uref{http://www.nongnu.org/grip/index.html}
@item
project page: @uref{https://savannah.nongnu.org/projects/grip}
@item
git repo: @uref{https://git.savannah.nongnu.org/cgit/grip.git}
@item
description:

@quotation
The idea is similar to the one expressed in Guile-Lib, that is, a place for
people to collaborate to the development of a common library, though less
intimidating maybe and, unlike Guile-Lib, Grip will tolerate, under strict
conditions, some C code: this is notably to support and boost Guile-CV
floating point operations, at least till Guile has an AOT compiler, able to
offer similar performance results for fixed size floating points and integer
operations.

@end quotation

(@uref{https://www.nongnu.org/grip/index.html})
@end itemize
@end itemize

@node Unsorted
@section Unsorted

@itemize
@item
CMOD-PLAY:
@itemize
@item
website: @uref{https://www.gnuvola.org/software/cmod-play/}
@item
description: ???
@end itemize

@item
@code{guile-mpd}: @uref{https://github.com/steveerhart/guile-mpd}
@item
@code{alias-generator}: @uref{https://gitlab.com/Formbi/alias-generator}
@item
@code{bloom-filter}: @uref{https://github.com/ijp/bloom-filter}
@item
@code{codejam practices}: @uref{https://github.com/jcca/codejam_practices}
@item
@code{guile-agentx}: @uref{https://github.com/securactive/guile-agentx}
@item
@code{guile-lfsr}:
@itemize
@item
git repo: @uref{https://gitlab.com/ft/guile-lfsr}
@item
description:

@quotation
    This library contains three scheme modules targetted at GNU Guile. The
(communication lfsr) module implements linear feedback shift registers as
infinite streams of bits. LFSRs are used, for example, to generate chip
sequences in CDMA systems, for synchronising preambles or as pseudo random
number generators. The module implements LFSRs in both Fibonacci and Galois
configurations.

-- @uref{https://gitlab.com/ft/guile-lfsr/-/blob/47724179fc3c0f6f4dddd20d189422b1ac9d3cdd/README}

@end quotation
@item
license: @uref{https://gitlab.com/ft/guile-lfsr/-/blob/47724179fc3c0f6f4dddd20d189422b1ac9d3cdd/LICENCE}
@end itemize

@item
@code{guile-e-series}
@itemize
@item
git repository: @uref{https://gitlab.com/ft/guile-e-series}
@item
description:
@quotation
E-Series Tools for GNU Guile
The E-Series are series of preferred numbers, commonly used to specify electro-
nic parts; mostly resistors, inductors  and capacitors. This library implements
two kinds of lookups: a) Given a value,  look up that value in all E-series and
return the values  surrounding the desired value; and b)  Given an integer that
identifies an E-Series  and a desired value, return combinations  of two parts,
that approximate the desired value as closely as possible.

[@dots{}]

-- @uref{https://gitlab.com/ft/guile-e-series/-/blob/7244035d25fc85898bacb76deacc89568aeff44f/README}

@end quotation
@item
license: @uref{https://gitlab.com/ft/guile-e-series/-/blob/7244035d25fc85898bacb76deacc89568aeff44f/LICENCE}
@end itemize
@end itemize

@node Projects
@chapter Projects

@itemize
@item
Guile 100
@itemize
@item
description:
@quotation
This is the repository for the Guile 100 Programs project. This is a collaborative effort to create a set of examples on how Guile might be used for real-world problems.

(@uref{https://github.com/spk121/guile100/blob/master/README.md})

@end quotation
@item
git repo: @uref{https://github.com/spk121/guile100/}
@item
website: @uref{http://www.lonelycactus.com/guile100/html/index.html}
@end itemize
@end itemize

@node Programming paradigm
@chapter Programming paradigm

@menu
* "Object-oriented programming"::
* Relational programming::
* Functional programming::
@end menu

@node "Object-oriented programming"
@section "Object-oriented programming"

@itemize
@item
GOOPS
@itemize
@item
GNU software manual page: @uref{https://www.gnu.org/software/guile/manual/html_node/GOOPS.html}
@end itemize
@end itemize

@menu
* Prototype based::
@end menu

@node Prototype based
@subsection Prototype based

@itemize
@item
Shelf
@itemize
@item
git repo: @uref{https://github.com/mwitmer/Shelf}
@end itemize
@end itemize

@node Relational programming
@section Relational programming

@itemize
@item
@code{minikanren}
@itemize
@item
git repository at GitHub: @uref{https://github.com/ijp/minikanren}
@item
miniKanren uncourse by William Byrd: @uref{https://duckduckgo.com/?q=minikanren+uncourse&t=h_&iax=videos&ia=videos&iai=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DiCuVTGWNU3s}
@end itemize
@end itemize

@node Functional programming
@section Functional programming

@itemize
@item
Monad implementations
@itemize
@item
git repository at GitHub: @uref{https://github.com/ijp/monad}
@end itemize

@item
Genshou: Extensible effects
@itemize
@item
website: @uref{https://git.sr.ht/~wklew/genshou}
@item
description: Implementation of a way to encapsulate side effects based on
@uref{http://okmij.org/ftp/Haskell/extensible/}. It helps dealing with side effects in a
functional way.
@end itemize
@end itemize

@node Programming language concepts
@chapter Programming language concepts

@menu
* Pipeline / pipe / chain / threading::
* State Machines::
@end menu

@node Pipeline / pipe / chain / threading
@section Pipeline / pipe / chain / threading

@itemize
@item
SRFI-197:
@itemize
@item
website: @uref{https://srfi.schemers.org/srfi-197/srfi-197.html}
@item
git repository: @uref{https://github.com/ar-nelson/srfi-197}
@end itemize
@item
macro examples:
@itemize
@item
git repository: @uref{https://notabug.org/ZelphirKaltstahl/guile-macros/src/master/threading-pipe-macro/macro-hygienic-syntax-rules.scm}
@item
description: simple pipeline macro implementation
@end itemize
@item
@code{guile-threading-macro.scm}
@itemize
@item
gist: @uref{https://gist.github.com/emanon-was/ed12f6023e2d6328334a}
@item
description: simple pipeline macro implementation
@end itemize
@item
@code{guile-threading-macros}
@itemize
@item
repository: @uref{https://hg.sr.ht/~bjoli/guile-threading-macros}
@item
description: Implements threading macros, which let you choose the position of the threaded argument at each step in the pipeline. Using SRFI-197 is recommended, once it is available in GNU Guile.
@end itemize
@end itemize

@node State Machines
@section State Machines

@itemize
@item
@samp{Guile-SMC}
@itemize
@item
git repository: @uref{https://github.com/artyom-poptsov/guile-smc}
@item
description: @emph{"GNU Guile state machine compiler."} -- @uref{https://github.com/artyom-poptsov/guile-smc/blob/d3a1dda50a64f1ac293d02ece1258006a0219e78/README.org}
@item
documentation: @uref{https://github.com/artyom-poptsov/guile-smc/tree/master/doc}
@end itemize
@end itemize

@node Programs
@chapter Programs

@menu
* Finances::
* Window manager: Window manager (1). 
* Other: Other (6). 
@end menu

@node Finances
@section Finances

@itemize
@item
ETRACK
@itemize
@item
git repository: @uref{https://gitlab.com/restio-al-restio/etrack/}
@item
description: @emph{"[@dots{}] a simple package to track expenses: query, add, delete, update.  You can use ETRACK from Emacs or from the command-line."} (@uref{https://gitlab.com/restio-al-restio/etrack/-/blob/fe360a7f6acdb855046c99b888c9f8a11084051c/README})
@end itemize
@end itemize

@node Window manager (1)
@section Window manager

@itemize
@item
@code{RPX}
@itemize
@item
repository: @uref{https://www.gnuvola.org/software/rpx/}
@item
description: @emph{"This is rpx, a port of ratpoison to Guile Scheme. [@dots{}]"} (@uref{https://www.gnuvola.org/software/rpx/})
@item
on nongnu: @uref{https://www.nongnu.org/ratpoison/}
@end itemize
@end itemize

@node Other (6)
@section Other

@itemize
@item
Starlet
@itemize
@item
repository: @uref{https://github.com/taw10/starlet}
@item
description:
@quotation
Starlet is an experimental Lisp-based domain-specific language (DSL) for theatrical lighting control. It's based on Guile and sends its DMX output via OLA to almost any type of lighting control interface - DMX, sACN, Art-Net etc.

-- @uref{https://github.com/taw10/starlet/blob/79df0f8c3289189387a4e07e24e507445ab85a4d/README.md}

@end quotation
@end itemize
@end itemize

@node Tools
@chapter Tools

@menu
* Notes::
* Editor support::
* Project management::
* Build tools::
@end menu

@node Notes
@section Notes

@itemize
@item
@code{guile-notes}
@itemize
@item
git repo: @uref{https://github.com/Halfwake/guile-notes}
@item
description: @emph{"A tool for saving a list of notes."} (@uref{https://github.com/Halfwake/guile-notes})
@end itemize
@end itemize

@node Editor support
@section Editor support

@itemize
@item
@code{guile.vim}
@itemize
@item
git repo: @uref{https://gitlab.com/HiPhish/guile.vim}
@item
description:
@quotation
This plugin extends Vim's Scheme support to include the additions to the language provided by the GNU Guile implementation. The plugin automatically detects whether a Scheme file is a Guile file and adds syntax highlighting for Guile's special forms.

(@uref{https://gitlab.com/HiPhish/guile.vim/-/blob/master/README.rst})

@end quotation
@end itemize

@item
@code{repl.nvim}
@itemize
@item
git repo: @uref{https://gitlab.com/HiPhish/repl.nvim/}
@item
description:
@quotation
REPL.nvim bring REPL support to Nvim! Use the built-in REPLs, add your own, or change the existing ones. Change settings in your init.vim or on the fly, make them global or local, use the existing ones or make your own.

(@uref{https://gitlab.com/HiPhish/repl.nvim/-/blob/master/README.rst})

@end quotation
@end itemize

@item
conjure
@itemize
@item
git repo: @uref{https://github.com/Olical/conjure}
@item
description: @emph{"Conjure is an interactive environment for evaluating code within your running program. [@dots{}]"} (@uref{https://github.com/Olical/conjure/blob/4dc7c745618a24799af44797c51af7cc308e42a4/README.adoc})
@end itemize

@item
Emacs Guile support
@itemize
@item
@code{guile-ide}
@itemize
@item
repository: @uref{https://framagit.org/Jeko/guile-ide}
@item
description: Emacs configuration file focusing on Guile development
@end itemize
@item
@code{flycheck-guile}
@item
@code{geiser-guile}
@end itemize

@item
TODO: other editors support
@end itemize

@node Project management
@section Project management

@itemize
@item
@code{guile-hall}
@itemize
@item
git repository at GitLab: @uref{https://gitlab.com/a-sassmannshausen/guile-hall}
@end itemize

@item
@code{homebrew-guile}: @uref{https://github.com/aconchillo/}

@item
@code{guile-debbugs}
@itemize
@item
git repo: @uref{http://savannah.gnu.org/git/?group=guile-debbugs}
@item
description: see @uref{http://git.savannah.nongnu.org/cgit/guile-debbugs.git/tree/README.org}
@end itemize
@end itemize

@menu
* Package managers::
* Time tracking::
@end menu

@node Package managers
@subsection Package managers

@itemize
@item
GUIX package search
@itemize
@item
website: @uref{https://hpc.guix.info/browse}
@item
Search for example for @code{^guile-} to find many Guile libraries and projects.
@end itemize

@item
@code{guildhall}
@itemize
@item
git repository at GitHub: @uref{https://github.com/ijp/guildhall}
@end itemize

@item
Akku
@itemize
@item
website: @uref{https://akkuscm.org/}
@item
description:
@quotation
Akku.scm is a language package manager for Scheme. It grabs hold of code and vigorously shakes it until it behaves properly.

(@uref{https://akkuscm.org/})

@end quotation
@end itemize
@end itemize

@node Time tracking
@subsection Time tracking

@itemize
@item
GNU Foliot
@itemize
@item
website: @uref{https://www.gnu.org/software/foliot/index.html}
@item
git repo: @uref{https://git.savannah.gnu.org/cgit/foliot.git}
@item
description:

@quotation
GNU Foliot is a small and easy to use time keeping application.

It can be used in a single user mode or by small organizations. Starting
with version 0.9.4, it can import other user's database, an essential
feature for remote collaborators.

The fields it handles are: a date, who, for whom, what, a duration, whether
or not to be charged and a description.

It includes, on the main application screen, a powerful dynamic filters
criteria mechanism, which lets you visualize, work on and print a subset of
your time keeping entries.

A printing templates system allows you to (pre)define, reuse and hence
quickly generate the pdf files and/or printed reports of your needs.

A version which will let users export an active filter based subset of their
time keeping entries is under work.

@end quotation

(@uref{https://www.gnu.org/software/foliot/index.html})
@end itemize
@end itemize

@node Build tools
@section Build tools

@itemize
@item
@code{potato-make}
@itemize
@item
repository: @uref{https://github.com/spk121/potato-make}
@item
description:
@quotation
Potato Make is a scheme library that aims to simplify the task of
maintaining, updating, and regenerating programs. It is inspired by the make
utility in POSIX@. With this library, you can write a build script in Guile
Scheme.

-- @uref{https://github.com/spk121/potato-make/blob/5e823c5f5a9a51f9f89681684e77636b32cb5669/README.md}

@end quotation
@end itemize
@end itemize

@node Blogs
@chapter Blogs

@itemize
@item
@uref{https://hyper.dev/}
@item
@uref{http://wingolog.org/}
@item
@uref{http://okmij.org/ftp/Scheme/}
@item
blog post about singletons in GNU Guile
@itemize
@item
website: @uref{http://hiphish.github.io/blog/2019/05/24/singleton-objects-in-guile-scheme/}
@end itemize
@end itemize

@node Other (7)
@chapter Other

@itemize
@item
SPH lib, collection of Guile libraries
@itemize
@item
website: @uref{http://sph.mn/computer/software/sph-lib.html}
@end itemize

@item
C2 Wiki Category Scheme
@itemize
@item
website: @uref{https://proxy.c2.com/cgi/wiki?CategoryScheme}
@end itemize

@item
C2 Wiki Guile Scheme
@itemize
@item
website: @uref{https://proxy.c2.com/cgi/wiki?GuileScheme}
@end itemize

@item
C2 Wiki Scheme Language
@itemize
@item
website: @uref{https://proxy.c2.com/cgi/wiki?SchemeLanguage}
@end itemize

@item
Community Scheme Wiki
@itemize
@item
general
@itemize
@item
website: @uref{http://community.schemewiki.org}
@end itemize
@item
Scheme FAQ
@itemize
@item
website: @uref{http://community.schemewiki.org/?scheme-faq-standards}
@end itemize
@end itemize

@item
SICP solutions
@itemize
@item
git repo: @uref{https://github.com/alpardal/SICP-guile}
@item
description:
@quotation
A SICP Study Guide With Exercise Solutions in Guile & Emacs Lisp

(@uref{https://github.com/alpardal/SICP-guile})

@end quotation
@end itemize

@item
Guile-BAUX
@itemize
@item
git repo: @uref{https://git.savannah.nongnu.org/cgit/guile-baux.git}
@item
description: A loose collection Guile modules:
@quotation
Guile-BAUX is a collection of scripts and modules intended to be installed in your
project’s aux dir (i.e., build-aux/, or equivalent dir specified by AC@math{_CONFIG}@math{_AUX}@math{_DIR} in
configure.ac). There are modules for:

@itemize
@item
extracting documentation / generating texinfo
@item
doing (Scheme) source-source scanning / transforming
@item
constructing / displaying modules’ dependency graph
@item
generating C boilerplate
@end itemize

[@dots{}]

-- @uref{https://www.gnuvola.org/software/guile-baux/guile-baux.pdf}

@end quotation
@end itemize

@item
@samp{gclip-select}
@itemize
@item
git repo: @uref{https://git.savannah.nongnu.org/cgit/gclip-select.git}
@item
description:
@quotation
This is gclip@math{_select}, a small program that allows you to re-select from the text
lines that were selected at one time or another as the X Primary Selection. This
is useful when, in X Windows, if you have selected something using the left
mouse button (as in the convention of the X Windows System) and you later
select something else but want to get back to the earlier selection.

Thus this program allows you to quickly switch between frequently copied texts
for pasting. When you select some text you will notice gclip@math{_select} window adds
the newly selected text to the list. And you can choose any earlier selection in
the list window to make it the X11 primary selection again; you can then paste it
using the middle mouse button.

-- @uref{https://git.savannah.nongnu.org/cgit/gclip-select.git/tree/README?id=b78bc3cd2d46bba590bddbbe0a7d43823635c249}

@end quotation
@end itemize
@end itemize

@node Other lists of Guile software
@chapter Other lists of Guile software

@itemize
@item
official GNU Guile website library list: @uref{https://www.gnu.org/software/guile/libraries/}
@item
SPH list: @uref{http://sph.mn/foreign/guile-software.html}
@end itemize

@node Videos / Talks / Presentations
@chapter Videos / Talks / Presentations

@itemize
@item
The GNU Guy:
@itemize
@item
@uref{https://video.hardlimit.com/videos/watch/95ddfcce-0be7-4d2c-a1d4-8017deedfdeb, Sending an Email via GNU Guile}
@item
@uref{https://video.hardlimit.com/videos/watch/37d822a2-0eed-4dd6-b230-5008d433503e, A tiny and incomplete intro to Scheme Macros}
@item
@uref{https://video.hardlimit.com/videos/watch/14e041a7-59dd-458f-aeca-5aa3e8a87a1e, Reporting A Guile Bug}
@item
@uref{https://video.hardlimit.com/videos/watch/playlist/da7e41c8-38df-443f-aef1-d14fc7206fcc, Guile Web Development} (playlist)
@end itemize
@end itemize

This category is still fairly empty. Help filling it with interesting GNU Guile related videos, talks or presentations!

@bye